This is ../../info/ccmode, produced by makeinfo version 4.13 from
cc-mode.texi.

This manual is for CC Mode in Emacs.

   Copyright (C) 1995-2012 Free Software Foundation, Inc.

     Permission is granted to copy, distribute and/or modify this
     document under the terms of the GNU Free Documentation License,
     Version 1.3 or any later version published by the Free Software
     Foundation; with no Invariant Sections, with the Front-Cover texts
     being "A GNU Manual", and with the Back-Cover Texts as in (a)
     below.  A copy of the license is included in the section entitled
     "GNU Free Documentation License".

     (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
     modify this GNU manual.  Buying copies from the FSF supports it in
     developing GNU and promoting software freedom."

INFO-DIR-SECTION Emacs editing modes
START-INFO-DIR-ENTRY
* CC Mode: (ccmode).            Emacs mode for editing C, C++, Objective-C,
                                Java, Pike, AWK, and CORBA IDL code.
END-INFO-DIR-ENTRY


File: ccmode,  Node: Concept and Key Index,  Prev: Variable Index,  Up: Top

Concept and Key Index
*********************

 [index ]
* Menu:

* #:                                     Electric Keys.       (line  24)
* #define:                               Macro Backslashes.   (line   6)
* (:                                     Electric Keys.       (line  63)
* ):                                     Electric Keys.       (line  64)
* *:                                     Electric Keys.       (line  37)
* ,:                                     Electric Keys.       (line  98)
* -block-intro symbols:                  Syntactic Symbols.   (line  18)
* -close symbols:                        Syntactic Symbols.   (line  18)
* -cont symbols:                         Syntactic Symbols.   (line  24)
* -intro symbols:                        Syntactic Symbols.   (line  24)
* -open symbols:                         Syntactic Symbols.   (line  18)
* /:                                     Electric Keys.       (line  38)
* ::                                     Electric Keys.       (line  85)
* ;:                                     Electric Keys.       (line  97)
* <:                                     Electric Keys.       (line  54)
* <backspace>:                           Hungry WS Deletion.  (line  79)
* <delete>:                              Hungry WS Deletion.  (line  79)
* >:                                     Electric Keys.       (line  55)
* Abbrev mode:                           Electric Keys.       (line 126)
* access-label:                          Class Symbols.       (line  40)
* action functions:                      Custom Braces.       (line   6)
* Adaptive Fill mode:                    Custom Filling and Breaking.
                                                              (line  58)
* anchor position <1>:                   Syntactic Analysis.  (line  22)
* anchor position:                       Indentation Engine Basics.
                                                              (line  15)
* annotation-top-cont:                   Java Symbols.        (line  27)
* annotation-var-cont:                   Java Symbols.        (line  27)
* announcement mailing list:             Mailing Lists and Bug Reports.
                                                              (line  27)
* arglist-close:                         Paren List Symbols.  (line  29)
* arglist-cont:                          Paren List Symbols.  (line  34)
* arglist-cont-nonempty:                 Paren List Symbols.  (line  34)
* arglist-intro:                         Paren List Symbols.  (line  29)
* Auto Fill mode:                        Filling and Breaking.
                                                              (line  19)
* auto-newline:                          Auto-newlines.       (line   6)
* AWK style:                             Built-in Styles.     (line  42)
* awk-mode.el:                           Introduction.        (line   6)
* block-close:                           Conditional Construct Symbols.
                                                              (line  28)
* block-open:                            Literal Symbols.     (line  50)
* BOCM:                                  Introduction.        (line   6)
* brace lists:                           Brace List Symbols.  (line   6)
* brace-entry-open:                      Brace List Symbols.  (line  25)
* brace-list-close:                      Brace List Symbols.  (line  19)
* brace-list-entry:                      Brace List Symbols.  (line  19)
* brace-list-intro:                      Brace List Symbols.  (line  19)
* brace-list-open:                       Brace List Symbols.  (line  19)
* BSD style:                             Built-in Styles.     (line  17)
* bug report mailing list:               Mailing Lists and Bug Reports.
                                                              (line  22)
* bugs:                                  Limitations and Known Bugs.
                                                              (line   6)
* c:                                     Literal Symbols.     (line  38)
* c++-mode.el:                           Introduction.        (line   6)
* C-c .:                                 Other Commands.      (line   9)
* C-c ::                                 Other Commands.      (line  26)
* C-c <backspace>:                       Hungry WS Deletion.  (line  67)
* C-c <DELETE>:                          Hungry WS Deletion.  (line  74)
* C-c C-<backspace>:                     Hungry WS Deletion.  (line  67)
* C-c C-<DELETE>:                        Hungry WS Deletion.  (line  74)
* C-c C-\:                               Other Commands.      (line  31)
* C-c C-a:                               Minor Modes.         (line  62)
* C-c C-b:                               Mailing Lists and Bug Reports.
                                                              (line   6)
* C-c C-c:                               Comment Commands.    (line   7)
* C-c C-d:                               Hungry WS Deletion.  (line  74)
* C-c C-DEL:                             Hungry WS Deletion.  (line  67)
* C-c C-e:                               Other Commands.      (line  57)
* C-c C-l:                               Minor Modes.         (line  58)
* C-c C-n:                               Movement Commands.   (line  97)
* C-c C-o <1>:                           Interactive Customization.
                                                              (line  73)
* C-c C-o:                               c-offsets-alist.     (line  41)
* C-c C-p:                               Movement Commands.   (line  97)
* C-c C-q:                               Indentation Commands.
                                                              (line 111)
* C-c C-s:                               Syntactic Analysis.  (line  42)
* C-c C-u:                               Movement Commands.   (line  67)
* C-c C-w:                               Minor Modes.         (line  72)
* C-c DEL:                               Hungry WS Deletion.  (line  67)
* C-d:                                   Hungry WS Deletion.  (line  48)
* C-j <1>:                               FAQ.                 (line  10)
* C-j:                                   Indentation Commands.
                                                              (line 102)
* C-M-\ <1>:                             FAQ.                 (line  27)
* C-M-\:                                 Indentation Commands.
                                                              (line 119)
* C-M-a (AWK Mode):                      Movement Commands.   (line  38)
* C-M-e (AWK Mode):                      Movement Commands.   (line  38)
* C-M-h:                                 Indentation Commands.
                                                              (line 125)
* C-M-q <1>:                             FAQ.                 (line  32)
* C-M-q:                                 Indentation Commands.
                                                              (line 106)
* C-M-u:                                 FAQ.                 (line  32)
* c-mode.el:                             Introduction.        (line   6)
* C-x h:                                 FAQ.                 (line  27)
* case-label:                            Switch Statement Symbols.
                                                              (line  26)
* catch-clause:                          Conditional Construct Symbols.
                                                              (line  44)
* class-close:                           Class Symbols.       (line  27)
* class-open:                            Class Symbols.       (line  27)
* clean-ups:                             Clean-ups.           (line   6)
* comment handling:                      Filling and Breaking.
                                                              (line   6)
* comment line prefix:                   Custom Filling and Breaking.
                                                              (line  11)
* comment-intro:                         Literal Symbols.     (line  33)
* comment-only line:                     Syntactic Analysis.  (line  80)
* comments (insertion of):               Comment Commands.    (line   6)
* composition-close:                     External Scope Symbols.
                                                              (line  38)
* composition-open:                      External Scope Symbols.
                                                              (line  38)
* Configuration:                         Config Basics.       (line   6)
* cpp-define-intro:                      Multiline Macro Symbols.
                                                              (line   6)
* cpp-macro:                             Literal Symbols.     (line  55)
* cpp-macro-cont:                        Multiline Macro Symbols.
                                                              (line   6)
* customization, brace hanging:          Custom Braces.       (line  14)
* customization, colon hanging:          Hanging Colons.      (line   6)
* customization, comma newlines:         Hanging Semicolons and Commas.
                                                              (line   6)
* customization, indentation:            Customizing Indentation.
                                                              (line   6)
* customization, indentation functions:  Custom Line-Up.      (line   6)
* customization, interactive:            Interactive Customization.
                                                              (line   6)
* customization, semicolon newlines:     Hanging Semicolons and Commas.
                                                              (line   6)
* defun-block-intro:                     Function Symbols.    (line  18)
* defun-close:                           Function Symbols.    (line  18)
* defun-open:                            Function Symbols.    (line  18)
* DEL:                                   Hungry WS Deletion.  (line  30)
* do-while-closure:                      Conditional Construct Symbols.
                                                              (line  50)
* documentation comments:                Doc Comments.        (line   6)
* electric characters:                   Electric Keys.       (line   6)
* Ellemtel style:                        Built-in Styles.     (line  27)
* else-clause:                           Conditional Construct Symbols.
                                                              (line  44)
* Emacs Initialization File:             Config Basics.       (line   6)
* extern-lang-close:                     External Scope Symbols.
                                                              (line  15)
* extern-lang-open:                      External Scope Symbols.
                                                              (line  15)
* faces:                                 Faces.               (line   6)
* file local variables:                  File Styles.         (line   6)
* Filladapt mode:                        Custom Filling and Breaking.
                                                              (line  73)
* Font Lock mode:                        Font Locking.        (line   6)
* font locking:                          Font Locking.        (line   6)
* friend:                                Class Symbols.       (line  93)
* func-decl-cont:                        Literal Symbols.     (line  31)
* GNU indent program:                    Indentation Commands.
                                                              (line  12)
* GNU style:                             Built-in Styles.     (line  10)
* GtkDoc markup:                         Doc Comments.        (line  50)
* hanging braces:                        Hanging Braces.      (line   6)
* hanging colons:                        Hanging Colons.      (line   6)
* hanging commas:                        Hanging Semicolons and Commas.
                                                              (line   6)
* hanging semicolons:                    Hanging Semicolons and Commas.
                                                              (line   6)
* history:                               Introduction.        (line   6)
* hungry-deletion:                       Hungry WS Deletion.  (line   6)
* in-class inline methods:               Class Symbols.       (line  59)
* inclass <1>:                           External Scope Symbols.
                                                              (line  15)
* inclass:                               Class Symbols.       (line  40)
* incomposition:                         External Scope Symbols.
                                                              (line  38)
* indentation <1>:                       Customizing Indentation.
                                                              (line   6)
* indentation <2>:                       Indentation Calculation.
                                                              (line   6)
* indentation:                           Indentation Commands.
                                                              (line   6)
* indentation function:                  Line-Up Functions.   (line   6)
* indentation offset specifications:     Indentation Engine Basics.
                                                              (line  22)
* inexpr-class:                          Java Symbols.        (line  20)
* inexpr-statement:                      Statement Block Symbols.
                                                              (line  16)
* inextern-lang:                         External Scope Symbols.
                                                              (line  15)
* inher-cont:                            Class Symbols.       (line  36)
* inher-intro:                           Class Symbols.       (line  36)
* inlambda:                              Statement Block Symbols.
                                                              (line  38)
* inline-close:                          Class Symbols.       (line  59)
* inline-open:                           Class Symbols.       (line  59)
* inmodule:                              External Scope Symbols.
                                                              (line  35)
* innamespace:                           External Scope Symbols.
                                                              (line  32)
* interactive customization:             Interactive Customization.
                                                              (line   6)
* Java style:                            Built-in Styles.     (line  38)
* Javadoc markup <1>:                    Doc Comments.        (line  44)
* Javadoc markup:                        Filling and Breaking.
                                                              (line  26)
* Just-in-time Lock mode:                Font Locking Preliminaries.
                                                              (line  49)
* K&R style:                             Built-in Styles.     (line  14)
* knr-argdecl:                           K&R Symbols.         (line   6)
* knr-argdecl-intro:                     K&R Symbols.         (line   6)
* label:                                 Literal Symbols.     (line  48)
* lambda-intro-cont:                     Statement Block Symbols.
                                                              (line  38)
* Lazy Lock mode:                        Font Locking Preliminaries.
                                                              (line  49)
* limitations:                           Limitations and Known Bugs.
                                                              (line   6)
* line breaking:                         Filling and Breaking.
                                                              (line   6)
* line-up function:                      Line-Up Functions.   (line   6)
* Linux style:                           Built-in Styles.     (line  32)
* literal <1>:                           Clean-ups.           (line  26)
* literal <2>:                           Auto-newlines.       (line  23)
* literal:                               Indentation Commands.
                                                              (line  67)
* M-;:                                   Comment Commands.    (line  15)
* M-a:                                   Movement Commands.   (line  50)
* M-e:                                   Movement Commands.   (line  50)
* M-j:                                   Filling and Breaking.
                                                              (line  42)
* M-q:                                   Filling and Breaking.
                                                              (line  26)
* macros:                                Custom Macros.       (line   6)
* macros with semicolons:                Macros with ;.       (line   6)
* member-init-cont:                      Class Symbols.       (line  53)
* member-init-intro:                     Class Symbols.       (line  53)
* Minor Modes:                           Minor Modes.         (line   6)
* mode hooks:                            CC Hooks.            (line   6)
* module-close:                          External Scope Symbols.
                                                              (line  35)
* module-open:                           External Scope Symbols.
                                                              (line  35)
* movement:                              Movement Commands.   (line   6)
* multiline macros:                      Multiline Macro Symbols.
                                                              (line   6)
* namespace-close:                       External Scope Symbols.
                                                              (line  32)
* namespace-open:                        External Scope Symbols.
                                                              (line  32)
* nomenclature:                          Subword Movement.    (line   6)
* objc-method-args-cont:                 Objective-C Method Symbols.
                                                              (line  18)
* objc-method-call-cont:                 Objective-C Method Symbols.
                                                              (line  18)
* objc-method-intro:                     Objective-C Method Symbols.
                                                              (line  18)
* offset specification:                  c-offsets-alist.     (line  59)
* offsets:                               Indentation Engine Basics.
                                                              (line  22)
* open paren in column zero:             FAQ.                 (line  51)
* paragraph filling:                     Filling and Breaking.
                                                              (line  19)
* performance:                           Performance Issues.  (line   6)
* Pike autodoc markup <1>:               Doc Comments.        (line  47)
* Pike autodoc markup:                   Filling and Breaking.
                                                              (line  26)
* preprocessor directives:               Custom Macros.       (line   6)
* Python style:                          Built-in Styles.     (line  35)
* RET:                                   FAQ.                 (line  10)
* statement:                             Function Symbols.    (line  28)
* statement-block-intro:                 Conditional Construct Symbols.
                                                              (line  28)
* statement-case-intro:                  Switch Statement Symbols.
                                                              (line  26)
* statement-case-open:                   Switch Statement Symbols.
                                                              (line  26)
* statement-cont:                        Function Symbols.    (line  28)
* stream-op:                             Literal Symbols.     (line  64)
* string:                                Literal Symbols.     (line  46)
* Stroustrup style:                      Built-in Styles.     (line  24)
* style definition:                      Adding Styles.       (line  13)
* style variables:                       Style Variables.     (line   6)
* styles <1>:                            Styles.              (line   6)
* styles:                                Style Variables.     (line   6)
* styles, built-in:                      Built-in Styles.     (line   6)
* styles, file local:                    File Styles.         (line   6)
* substatement <1>:                      Conditional Construct Symbols.
                                                              (line  35)
* substatement:                          Syntactic Analysis.  (line  77)
* substatement block:                    Syntactic Analysis.  (line  77)
* substatement-label:                    Conditional Construct Symbols.
                                                              (line  39)
* substatement-open:                     Conditional Construct Symbols.
                                                              (line  28)
* subword:                               Subword Movement.    (line   6)
* syntactic analysis:                    Syntactic Analysis.  (line   6)
* syntactic context:                     Syntactic Analysis.  (line   6)
* syntactic element:                     Syntactic Analysis.  (line   6)
* syntactic symbol <1>:                  Syntactic Analysis.  (line  14)
* syntactic symbol:                      Indentation Engine Basics.
                                                              (line  15)
* syntactic symbols, brief list:         Syntactic Symbols.   (line   6)
* syntactic whitespace <1>:              Multiline Macro Symbols.
                                                              (line   6)
* syntactic whitespace <2>:              Literal Symbols.     (line  40)
* syntactic whitespace:                  Auto-newlines.       (line  23)
* TAB:                                   Indentation Commands.
                                                              (line  42)
* template-args-cont:                    Class Symbols.       (line 103)
* text filling:                          Filling and Breaking.
                                                              (line   6)
* topmost-intro:                         Function Symbols.    (line  18)
* topmost-intro-cont:                    Function Symbols.    (line  18)
* types, user defined:                   Font Locking Preliminaries.
                                                              (line  55)
* user defined types:                    Font Locking Preliminaries.
                                                              (line  55)
* User style:                            Built-in Styles.     (line  46)
* web site:                              Updating CC Mode.    (line   9)
* Whitesmith style:                      Built-in Styles.     (line  20)
* {:                                     Electric Keys.       (line  76)
* }:                                     Electric Keys.       (line  77)


